﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Community.CsharpSqlite
{
    class ConfigOption
    {

        /*
    ** CAPI3REF: Configuration Options
    ** EXPERIMENTAL
    **
    ** These constants are the available integer configuration options that
    ** can be passed as the first argument to the [ConfigHelper.Sqlite3Config()] interface.
    **
    ** New configuration options may be added in future releases of SQLite.
    ** Existing configuration options might be discontinued.  Applications
    ** should check the return code from [ConfigHelper.Sqlite3Config()] to make sure that
    ** the call worked.  The [ConfigHelper.Sqlite3Config()] interface will return a
    ** non-zero [error code] if a discontinued or unsupported configuration option
    ** is invoked.
    **
    ** <dl>
    ** <dt>ConfigOption.SQLITE_CONFIG_SINGLETHREAD</dt>
    ** <dd>There are no arguments to this option.  ^This option sets the
    ** [threading mode] to Single-thread.  In other words, it disables
    ** all mutexing and puts SQLite into a mode where it can only be used
    ** by a single thread.   ^If SQLite is compiled with
    ** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
    ** it is not possible to change the [threading mode] from its default
    ** value of Single-thread and so [ConfigHelper.Sqlite3Config()] will return 
    ** [StatusCode.SQLITE_ERROR] if called with the ConfigOption.SQLITE_CONFIG_SINGLETHREAD
    ** configuration option.</dd>
    **
    ** <dt>ConfigOption.SQLITE_CONFIG_MULTITHREAD</dt>
    ** <dd>There are no arguments to this option.  ^This option sets the
    ** [threading mode] to Multi-thread.  In other words, it disables
    ** mutexing on [database connection] and [prepared statement] objects.
    ** The application is responsible for serializing access to
    ** [database connections] and [prepared statements].  But other mutexes
    ** are enabled so that SQLite will be safe to use in a multi-threaded
    ** environment as long as no two threads attempt to use the same
    ** [database connection] at the same time.  ^If SQLite is compiled with
    ** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
    ** it is not possible to set the Multi-thread [threading mode] and
    ** [ConfigHelper.Sqlite3Config()] will return [StatusCode.SQLITE_ERROR] if called with the
    ** ConfigOption.SQLITE_CONFIG_MULTITHREAD configuration option.</dd>
    **
    ** <dt>ConfigOption.SQLITE_CONFIG_SERIALIZED</dt>
    ** <dd>There are no arguments to this option.  ^This option sets the
    ** [threading mode] to Serialized. In other words, this option enables
    ** all mutexes including the recursive
    ** mutexes on [database connection] and [prepared statement] objects.
    ** In this mode (which is the default when SQLite is compiled with
    ** [SQLITE_THREADSAFE=1]) the SQLite library will itself serialize access
    ** to [database connections] and [prepared statements] so that the
    ** application is free to use the same [database connection] or the
    ** same [prepared statement] in different threads at the same time.
    ** ^If SQLite is compiled with
    ** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
    ** it is not possible to set the Serialized [threading mode] and
    ** [ConfigHelper.Sqlite3Config()] will return [StatusCode.SQLITE_ERROR] if called with the
    ** ConfigOption.SQLITE_CONFIG_SERIALIZED configuration option.</dd>
    **
    ** <dt>ConfigOption.SQLITE_CONFIG_MALLOC</dt>
    ** <dd> ^(This option takes a single argument which is a pointer to an
    ** instance of the [sqlite3_mem_methods] structure.  The argument specifies
    ** alternative low-level memory allocation routines to be used in place of
    ** the memory allocation routines built into SQLite.)^ ^SQLite makes
    ** its own public copy of the content of the [sqlite3_mem_methods] structure
    ** before the [ConfigHelper.Sqlite3Config()] call returns.</dd>
    **
    ** <dt>ConfigOption.SQLITE_CONFIG_GETMALLOC</dt>
    ** <dd> ^(This option takes a single argument which is a pointer to an
    ** instance of the [sqlite3_mem_methods] structure.  The [sqlite3_mem_methods]
    ** structure is filled with the currently defined memory allocation routines.)^
    ** This option can be used to overload the default memory allocation
    ** routines with a wrapper that simulations memory allocation failure or
    ** tracks memory usage, for example. </dd>
    **
    ** <dt>ConfigOption.SQLITE_CONFIG_MEMSTATUS</dt>
    ** <dd> ^This option takes single argument of type int, interpreted as a 
    ** boolean, which enables or disables the collection of memory allocation 
    ** statistics. ^(When memory allocation statistics are disabled, the 
    ** following SQLite interfaces become non-operational:
    **   <ul>
    **   <li> [sqlite3_memory_used()]
    **   <li> [sqlite3_memory_highwater()]
    **   <li> [sqlite3_soft_heap_limit()]
    **   <li> [StatusHelper.GetStatus()]
    **   </ul>)^
    ** ^Memory allocation statistics are enabled by default unless SQLite is
    ** compiled with [Const.SQLITE_DEFAULT_MEMSTATUS]=0 in which case memory
    ** allocation statistics are disabled by default.
    ** </dd>
    **
    ** <dt>ConfigOption.SQLITE_CONFIG_SCRATCH</dt>
    ** <dd> ^This option specifies a static memory buffer that SQLite can use for
    ** scratch memory.  There are three arguments:  A pointer an 8-byte
    ** aligned memory buffer from which the scrach allocations will be
    ** drawn, the size of each scratch allocation (sz),
    ** and the maximum number of scratch allocations (N).  The sz
    ** argument must be a multiple of 16. The sz parameter should be a few bytes
    ** larger than the actual scratch space required due to internal overhead.
    ** The first argument must be a pointer to an 8-byte aligned buffer
    ** of at least sz*N bytes of memory.
    ** ^SQLite will use no more than one scratch buffer per thread.  So
    ** N should be set to the expected maximum number of threads.  ^SQLite will
    ** never require a scratch buffer that is more than 6 times the database
    ** page size. ^If SQLite needs needs additional scratch memory beyond 
    ** what is provided by this configuration option, then 
    ** [Malloc.sqlite3_malloc()] will be used to obtain the memory needed.</dd>
    **
    ** <dt>ConfigOption.SQLITE_CONFIG_PAGECACHE</dt>
    ** <dd> ^This option specifies a static memory buffer that SQLite can use for
    ** the database page cache with the default page cache implemenation.  
    ** This configuration should not be used if an application-define page
    ** cache implementation is loaded using the ConfigOption.SQLITE_CONFIG_PCACHE option.
    ** There are three arguments to this option: A pointer to 8-byte aligned
    ** memory, the size of each page buffer (sz), and the number of pages (N).
    ** The sz argument should be the size of the largest database page
    ** (a power of two between 512 and 32768) plus a little extra for each
    ** page header.  ^The page header size is 20 to 40 bytes depending on
    ** the host architecture.  ^It is harmless, apart from the wasted memory,
    ** to make sz a little too large.  The first
    ** argument should point to an allocation of at least sz*N bytes of memory.
    ** ^SQLite will use the memory provided by the first argument to satisfy its
    ** memory needs for the first N pages that it adds to cache.  ^If additional
    ** page cache memory is needed beyond what is provided by this option, then
    ** SQLite goes to [Malloc.sqlite3_malloc()] for the additional storage space.
    ** ^The implementation might use one or more of the N buffers to hold 
    ** memory accounting information. The pointer in the first argument must
    ** be aligned to an 8-byte boundary or subsequent behavior of SQLite
    ** will be undefined.</dd>
    **
    ** <dt>ConfigOption.SQLITE_CONFIG_HEAP</dt>
    ** <dd> ^This option specifies a static memory buffer that SQLite will use
    ** for all of its dynamic memory allocation needs beyond those provided
    ** for by [ConfigOption.SQLITE_CONFIG_SCRATCH] and [ConfigOption.SQLITE_CONFIG_PAGECACHE].
    ** There are three arguments: An 8-byte aligned pointer to the memory,
    ** the number of bytes in the memory buffer, and the minimum allocation size.
    ** ^If the first pointer (the memory pointer) is NULL, then SQLite reverts
    ** to using its default memory allocator (the system malloc() implementation),
    ** undoing any prior invocation of [ConfigOption.SQLITE_CONFIG_MALLOC].  ^If the
    ** memory pointer is not NULL and either [SQLITE_ENABLE_MEMSYS3] or
    ** [SQLITE_ENABLE_MEMSYS5] are defined, then the alternative memory
    ** allocator is engaged to handle all of SQLites memory allocation needs.
    ** The first pointer (the memory pointer) must be aligned to an 8-byte
    ** boundary or subsequent behavior of SQLite will be undefined.</dd>
    **
    ** <dt>ConfigOption.SQLITE_CONFIG_MUTEX</dt>
    ** <dd> ^(This option takes a single argument which is a pointer to an
    ** instance of the [sqlite3_mutex_methods] structure.  The argument specifies
    ** alternative low-level mutex routines to be used in place
    ** the mutex routines built into SQLite.)^  ^SQLite makes a copy of the
    ** content of the [sqlite3_mutex_methods] structure before the call to
    ** [ConfigHelper.Sqlite3Config()] returns. ^If SQLite is compiled with
    ** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
    ** the entire mutexing subsystem is omitted from the build and hence calls to
    ** [ConfigHelper.Sqlite3Config()] with the ConfigOption.SQLITE_CONFIG_MUTEX configuration option will
    ** return [StatusCode.SQLITE_ERROR].</dd>
    **
    ** <dt>ConfigOption.SQLITE_CONFIG_GETMUTEX</dt>
    ** <dd> ^(This option takes a single argument which is a pointer to an
    ** instance of the [sqlite3_mutex_methods] structure.  The
    ** [sqlite3_mutex_methods]
    ** structure is filled with the currently defined mutex routines.)^
    ** This option can be used to overload the default mutex allocation
    ** routines with a wrapper used to track mutex usage for performance
    ** profiling or testing, for example.   ^If SQLite is compiled with
    ** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
    ** the entire mutexing subsystem is omitted from the build and hence calls to
    ** [ConfigHelper.Sqlite3Config()] with the ConfigOption.SQLITE_CONFIG_GETMUTEX configuration option will
    ** return [StatusCode.SQLITE_ERROR].</dd>
    **
    ** <dt>ConfigOption.SQLITE_CONFIG_LOOKASIDE</dt>
    ** <dd> ^(This option takes two arguments that determine the default
    ** memory allocation for the lookaside memory allocator on each
    ** [database connection].  The first argument is the
    ** size of each lookaside buffer slot and the second is the number of
    ** slots allocated to each database connection.)^  ^(This option sets the
    ** <i>default</i> lookaside size. The [ConfigOption.SQLITE_DBCONFIG_LOOKASIDE]
    ** verb to [sqlite3_db_config()] can be used to change the lookaside
    ** configuration on individual connections.)^ </dd>
    **
    ** <dt>ConfigOption.SQLITE_CONFIG_PCACHE</dt>
    ** <dd> ^(This option takes a single argument which is a pointer to
    ** an [sqlite3_pcache_methods] object.  This object specifies the interface
    ** to a custom page cache implementation.)^  ^SQLite makes a copy of the
    ** object and uses it for page cache memory allocations.</dd>
    **
    ** <dt>ConfigOption.SQLITE_CONFIG_GETPCACHE</dt>
    ** <dd> ^(This option takes a single argument which is a pointer to an
    ** [sqlite3_pcache_methods] object.  SQLite copies of the current
    ** page cache implementation into that object.)^ </dd>
    **
    ** </dl>
    */

        //#define ConfigOption.SQLITE_CONFIG_SINGLETHREAD  1  /* nil */
        //#define ConfigOption.SQLITE_CONFIG_MULTITHREAD   2  /* nil */
        //#define ConfigOption.SQLITE_CONFIG_SERIALIZED    3  /* nil */
        //#define ConfigOption.SQLITE_CONFIG_MALLOC        4  /* sqlite3_mem_methods* */
        //#define ConfigOption.SQLITE_CONFIG_GETMALLOC     5  /* sqlite3_mem_methods* */
        //#define ConfigOption.SQLITE_CONFIG_SCRATCH       6  /* void*, int sz, int N */
        //#define ConfigOption.SQLITE_CONFIG_PAGECACHE     7  /* void*, int sz, int N */
        //#define ConfigOption.SQLITE_CONFIG_HEAP          8  /* void*, int nByte, int min */
        //#define ConfigOption.SQLITE_CONFIG_MEMSTATUS     9  /* boolean */
        //#define ConfigOption.SQLITE_CONFIG_MUTEX        10  /* sqlite3_mutex_methods* */
        //#define ConfigOption.SQLITE_CONFIG_GETMUTEX     11  /* sqlite3_mutex_methods* */
        ///* previously SQLITE_CONFIG_CHUNKALLOC 12 which is now unused. */ 
        //#define ConfigOption.SQLITE_CONFIG_LOOKASIDE    13  /* int int */
        //#define ConfigOption.SQLITE_CONFIG_PCACHE       14  /* sqlite3_pcache_methods* */
        //#define ConfigOption.SQLITE_CONFIG_GETPCACHE    15  /* sqlite3_pcache_methods* */
        //#define ConfigOption.SQLITE_CONFIG_LOG          16  /* xFunc, void* */
        public const int SQLITE_CONFIG_SINGLETHREAD = 1; /* nil */
        public const int SQLITE_CONFIG_MULTITHREAD = 2; /* nil */
        public const int SQLITE_CONFIG_SERIALIZED = 3; /* nil */
        public const int SQLITE_CONFIG_MALLOC = 4; /* sqlite3_mem_methods* */
        public const int SQLITE_CONFIG_GETMALLOC = 5; /* sqlite3_mem_methods* */
        public const int SQLITE_CONFIG_SCRATCH = 6; /* void*, int sz, int N */
        public const int SQLITE_CONFIG_PAGECACHE = 7; /* void*, int sz, int N */
        public const int SQLITE_CONFIG_HEAP = 8; /* void*, int nByte, int min */
        public const int SQLITE_CONFIG_MEMSTATUS = 9; /* boolean */
        public const int SQLITE_CONFIG_MUTEX = 10; /* sqlite3_mutex_methods* */
        public const int SQLITE_CONFIG_GETMUTEX = 11; /* sqlite3_mutex_methods* */
        public const int SQLITE_CONFIG_LOOKASIDE = 13; /* int int */
        public const int SQLITE_CONFIG_PCACHE = 14; /* sqlite3_pcache_methods* */
        public const int SQLITE_CONFIG_GETPCACHE = 15; /* sqlite3_pcache_methods* */
        public const int SQLITE_CONFIG_LOG = 16; /* xFunc, void* */



        /*
    ** CAPI3REF: Configuration Options
    ** EXPERIMENTAL
    **
    ** These constants are the available integer configuration options that
    ** can be passed as the second argument to the [sqlite3_db_config()] interface.
    **
    ** New configuration options may be added in future releases of SQLite.
    ** Existing configuration options might be discontinued.  Applications
    ** should check the return code from [sqlite3_db_config()] to make sure that
    ** the call worked.  ^The [sqlite3_db_config()] interface will return a
    ** non-zero [error code] if a discontinued or unsupported configuration option
    ** is invoked.
    **
    ** <dl>
    ** <dt>ConfigOption.SQLITE_DBCONFIG_LOOKASIDE</dt>
    ** <dd> ^This option takes three additional arguments that determine the 
    ** [lookaside memory allocator] configuration for the [database connection].
    ** ^The first argument (the third parameter to [sqlite3_db_config()] is a
    ** pointer to an memory buffer to use for lookaside memory.
    ** ^The first argument after the ConfigOption.SQLITE_DBCONFIG_LOOKASIDE verb
    ** may be NULL in which case SQLite will allocate the
    ** lookaside buffer itself using [Malloc.sqlite3_malloc()]. ^The second argument is the
    ** size of each lookaside buffer slot.  ^The third argument is the number of
    ** slots.  The size of the buffer in the first argument must be greater than
    ** or equal to the product of the second and third arguments.  The buffer
    ** must be aligned to an 8-byte boundary.  ^If the second argument to
    ** ConfigOption.SQLITE_DBCONFIG_LOOKASIDE is not a multiple of 8, it is internally
    ** rounded down to the next smaller
    ** multiple of 8.  See also: [ConfigOption.SQLITE_CONFIG_LOOKASIDE]</dd>
    **
    ** </dl>
    */
        //#define ConfigOption.SQLITE_DBCONFIG_LOOKASIDE    1001  /* void* int int */
        public const int SQLITE_DBCONFIG_LOOKASIDE = 1001; /* void* int int */

    }
}
